Determining disorder in technological system architectures for computer systems

ABSTRACT

A method, computer program product, and a system to generate a total disorder value for architecture of a computing system include a processor(s) obtaining architecture detail for the computing system (the computing system includes function point(s)), and requirements defining aspirational performance benchmarks for the function point(s). The processor(s) identifies physical computing components within the computing systems comprising associated with each of the function points. For each function point, the processor(s) identifies architectural decisions and determines a disorder value for each decision. The processor(s) generates a total disorder value for the architecture detail by summing the disorder values for each function point. The processor(s) determines if the total disorder value exceeds a pre-defined threshold total disorder value for the computing system.

BACKGROUND

Designing technical architectures for computer systems is a largelymanual process that is undertaken by subject matter experts in computingarchitectures. Various methodologies have been documented to guide theseprocesses and assumptions are made that provided these methodologies arefollowed by the individuals undertaking the design processes, theresultant architecture will be ordered, meaning that it will controlentropy and minimize chaos. The efficacy of these methodologies incurrently unsupported by quantitative analyses.

SUMMARY

Shortcomings of the prior art are overcome and additional advantages areprovided through the provision of a method for determining the qualityof a technical architecture for a computing system. The method includes,for instance: obtaining, by one or more processors, architecture detailfor a given computing system, wherein the given computing systemcomprises one or more function points enabling specific functions withinthe given computing system, and requirements defining aspirationalperformance benchmarks for the function points within the givencomputing system; identifying, by the one or more processors, physicalcomputing components within the given computing systems comprisingportions of the architecture detail associated with each of the one ormore function points; for each function point and the associated portionof the architecture detail: identifying, by the one or more processors,one or more architectural decisions in the associated portion;determining, by the one or more processors, a disorder value for eacharchitectural decision of the one or more architectural decisions on theassociated portion; generating, by the one or more processors, a totaldisorder value for the architecture detail based on summing the disordervalues for each function point of the one or more function points of thearchitectural detail; and determining, by the one or more processors, ifthe total disorder value exceeds a pre-defined threshold total disordervalue for the given computing system.

Shortcomings of the prior art are overcome and additional advantages areprovided through the provision of a computer program product fordetermining the quality of a technical architecture for a computingsystem. The computer program product comprises a storage medium readableby a processing circuit and storing instructions for execution by theprocessing circuit for performing a method. The method includes, forinstance: obtaining, by one or more processors, architecture detail fora given computing system, wherein the given computing system comprisesone or more function points enabling specific functions within the givencomputing system, and requirements defining aspirational performancebenchmarks for the function points within the given computing system;identifying, by the one or more processors, physical computingcomponents within the given computing systems comprising portions of thearchitecture detail associated with each of the one or more functionpoints; for each function point and the associated portion of thearchitecture detail: identifying, by the one or more processors, one ormore architectural decisions in the associated portion; determining, bythe one or more processors, a disorder value for each architecturaldecision of the one or more architectural decisions on the associatedportion; generating, by the one or more processors, a total disordervalue for the architecture detail based on summing the disorder valuesfor each function point of the one or more function points of thearchitectural detail; and determining, by the one or more processors, ifthe total disorder value exceeds a pre-defined threshold total disordervalue for the given computing system.

Methods and systems relating to one or more aspects are also describedand claimed herein. Further, services relating to one or more aspectsare also described and may be claimed herein.

Additional features are realized through the techniques describedherein. Other embodiments and aspects are described in detail herein andare considered a part of the claimed aspects.

BRIEF DESCRIPTION OF THE DRAWINGS

One or more aspects are particularly pointed out and distinctly claimedas examples in the claims at the conclusion of the specification. Theforegoing and objects, features, and advantages of one or more aspectsare apparent from the following detailed description taken inconjunction with the accompanying drawings in which:

FIG. 1 is a workflow that illustrates certain aspects of someembodiments of the present invention;

FIG. 2 (including FIGS. 2A-2C) is a technical architecture that can beevaluated utilizing aspects of some embodiments of the presentinvention;

FIG. 3 is a simplified view of the technical architecture of FIG. 2.

FIG. 4 is a technical architecture that can be evaluated utilizingaspects of some embodiments of the present invention;

FIG. 5 is a simplified view of the technical architecture of FIG. 4.

FIG. 6 depicts a technical environment into which various aspects ofsome embodiments of the present invention can be implemented;

FIG. 7 depicts one embodiment of a computing node that can be utilizedin a cloud computing environment;

FIG. 8 depicts a cloud computing environment according to an embodimentof the present invention; and

FIG. 9 depicts abstraction model layers according to an embodiment ofthe present invention.

DETAILED DESCRIPTION

The accompanying figures, in which like reference numerals refer toidentical or functionally similar elements throughout the separate viewsand which are incorporated in and form a part of the specification,further illustrate the present invention and, together with the detaileddescription of the invention, serve to explain the principles of thepresent invention. As understood by one of skill in the art, theaccompanying figures are provided for ease of understanding andillustrate aspects of certain embodiments of the present invention. Theinvention is not limited to the embodiments depicted in the figures.

As understood by one of skill in the art, program code, as referred tothroughout this application, includes both software and hardware. Forexample, program code in certain embodiments of the present inventionincludes fixed function hardware, while other embodiments utilized asoftware-based implementation of the functionality described. Certainembodiments combine both types of program code. One example of programcode, also referred to as one or more programs, is depicted in FIG. 7 asprogram/utility 40, having a set (at least one) of program modules 42,may be stored in memory 28.

Embodiments of the present invention include a computer-implementedmethod, a computer program product, and a computer system where programcode executing on at least one processor enables a method forobjectively determining a quality value of a technical architecture of acomputing environment, including but not limited to a distributedcomputing environment, such as a cloud computing environment. Thisquality value is based on the determined order of the system, by theprogram code. A system with a given value attributed to its orderindicates that the system includes a threshold level of chaoticbehaviors (e.g., disorder) and the architecture controls entropy to aknown degree. These values or measures can be relative to other systems,evaluated by the program code, over time, and can be represented by avalue on a given scale, established over time, for example, throughmachine learning focused on the continuous evaluation of various systemarchitectures for one or more computing systems, by the program code. Inthis manner, program code in embodiments of the present inventionprovides an objective measure of architecture quality.

In some embodiments of the present invention, program code determines(e.g., evaluates, measures, etc.) quality of a given architecture for agiven computing environment through machine learning that includesdigesting reference models over a period of time to enable the programcode to compare quality of the given architecture (model) with thedigested references to generate metrics to utilize in assigning valuesto the technical architecture. In certain embodiments of the presentinvention the program code both generates and applies the (e.g.,machine-learned) metrics through a number of aspects, including but notlimited to: 1) utilizing technical architectural features, including butnot limited to, function placement, data source, and integration type,to monitor a net quality of the architecture of a given system; 2) Foreach architectural decision in the design, evaluating the relevantinstance and type of architectural decision, based on a pre-defined setof principles, standards and policies, to determine a quality (value)for the decision; and 3) deriving a numeric value for the given systemarchitecture by applying a disorder formula, where the numeric value isbased on aspects of the system architecture, including but not limitedto, data sources, integration types, weights assigned to (program codedetermined) best (design) decision(s) related to aspects of thearchitecture design, weights assigned to (program code determined) worstdecision(s), weights assigned to (program code determined) in-betweendecision, and actual decisions in the architecture relative to the(program code determined) best decisions.

As discussed above, designing a technical architecture for a computingsystem is often a manual process where a subject matter expert, in thiscase, an information technology (IT) architect, may follow wellestablished principles to formulate the architecture of a computingsystem, sometimes referred to as an IT system. Presently, although aneed can arise to determine whether the (now executed) design hasprovided a desired quality of architecture to the computing system,often, an architecture is not evaluated to determine if the realitymatches the aspirational design. Many existing quality evaluationapproaches do not provide a quantitative measure of whether anarchitecture is meeting a defined quality requirement. Whenarchitectures are not quantitatively evaluated pre-implementation and/orpost-implementation, the risk of system failure and potential costs andinefficiencies can escalate.

The quantitative evaluation of a system architecture provided inembodiments of the present invention is an objective measurement of thequality of the architecture. A quality architecture, according toevaluations performed by embodiments of the present invention, bringsorder to an architecture and prevents chaos within the computing system,through the implementation of this order. For example, an effectivearchitecture reduces and controls the entropy of a system. Inembodiments of the present invention, the program code derives a metricfor architecture quality, which can based on machine learning, andassigns a value from this metric representing the disorder of a systemto the architecture of the system. Thus, the program code in embodimentsof the present invention enables an objective measurement of the qualityof an architecture, compared with other systems, and changes withinthese systems and the system being evaluated, over time.

Embodiments of the present invention are inextricably tied to computing.Aspects of various embodiments of the present invention address achallenge unique to computing, i.e., determining, quantitatively,quality of a technical architecture. Embodiments of the presentinvention deal with an issue unique to computing: determining thequality of the architecture of a computing system relative to thefunctionality and expectations of the system. Embodiments of the presentinvention provide a unique approach to this issue as a practicalapplication to address this technical issue. Aspects of the presentinvention isolate particular issues that are negatively impacting thequality of a technical architecture and provide controls that enable auser to target these issues and/or enable the program code to implementarchitecture changes automatically, that improve the quality of thewhole.

Embodiments of the present invention provide a significant advantageover existing methods of technical architecture evaluation. For example,in embodiments of the present invention, the program code automaticallyevaluates the quality of a system architecture, based on a set ofdefined properties of the architecture, and the quality is indicative ofa level of disorder within the architecture. The level is based on ametric that categorizes or buckets the disorder of the architecturerelative to other architectures, over time. Thus, the process ofevaluating architectures in embodiments of the present invention isautomatic, repeatable, objective, and quantitative. At least thesequalities distinguish it from existing approaches to technicalarchitecture evaluation, including but not limited to peer review,governance board review, reference architecture comparison, and totalcost of ownership comparison. Unlike peer review, the program code inembodiments of the present invention consistently evaluates eachdecision within an architecture using consistent criteria to render anobjective result; peer reviews not only vary in evaluation criteria,they also do not result in an objective measure for architecture qualityassessment. Similarly, review by a governance review board or a memberof the board also produces a subjective result, depending upon theindividual(s) involved, and the result is also not a measure forarchitecture quality assessment. Reference architecture comparisonassumes the existence and correct selection of another architecture forcomparison. In embodiments of the present invention, the program codegains intelligence (machine learns) from varied architectures, overtime, in order to provide a result that categorizes the evaluatedarchitecture in the context of architecture, in general, rather than ina limited context of comparison to a selected architecture, only. Totalcost of ownership evaluation relies on analyzing comparative costs in arelevant architecture in order to provide a cost analysis. This exercisedoes not produce an objective measure of technical architecture quality.

In embodiments of the present invention, program code executing on oneor more processors determines a quality (value) of a system architecturefor a computing system based on elements of architectural features ofthe system architecture, including but not limited to: functionplacement, data source, and integration type. Within this framework, theprogram code, in some embodiments of the present invention, evaluatesthe quality of each instance and type of architectural decision, basedon a set of pre-defined principles, standards and/or policies. In someembodiments, based on this evaluation, the program code determines thateach decision is either ideal, less than ideal or the worst. Thisranking system is provided as an example, however, in embodiments of thepresent invention, in order to provide a quantitative evaluation oftechnical architecture quality, the program code buckets each decisioninto a defined quality rank and/or level, that is defined by certainmetes and bounds. In this way, as the program code digests/learnsdifferent system architectures, the program code can evaluate eacharchitecture relative to past architectures, which progressivelyincreases the intelligence of the program code in determining quality offuture technical architectures.

As aforementioned, as will be discussed in greater detail herein, inembodiments of the present invention, the program code applies adisorder formula to existing system architectures in order to determinethe quality of these architectures. In embodiments of the presentinvention, the program code applies what is referred to herein as adisorder formula (for ease of understanding) by assigning a numericvalue to elements in a technical architecture based on aspects of thatarchitecture, including but not limited to, the number of functions,data sources and integration types, and weights assigned to bestdecision(s), worst decision(s) and in-between decision(s) (i.e.,decision(s) that are not determined by the program code to be eitherbest or worst), and the actual decisions relative to the best decisionsthat could have been made (as determined by the program code).Architecture quality is inversely proportional to disorder. A higherquality technical architecture is a technical architecture with adisorder closer to zero. As understood by one of skill in the art, thehigher the disorder within a technical architecture of a computingsystem, the more chaotic the architecture is, rendering it difficult tomanage, expensive to change, and/or susceptible to functional risk.

FIG. 1 is a workflow 100 that illustrates various aspects of someembodiments of the present invention. These aspects will be illustratedin further detail in non-limiting examples provided herein. Referring toFIG. 1, in some embodiments of the present invention, program codeexecuting on one or more processors obtains architecture detail for agiven computing system (110). The architectural detail defines thearchitectural landscape (metes and bounds and data in-between) to beevaluated by the program code. In an embodiments of the presentinvention, the program code identifies one or more function points inthe architecture detail (120). As will be illustrated in the examplesthat follow, the program code evaluates the quality of a givenarchitecture detail based on a pre-defined set of architectural featuresthat comprise the architecture detail. The program code bases thequality determination on these pre-defined evaluated features,determining a net quality of the system architecture based on thepre-defined evaluated features. In some embodiments of the presentinvention, the features pre-defined evaluated features for each functionpoint include: function placement, data source, and integration type.The program code determines an overall quality of the architecture basedon individual architecture function point values. As illustrated in FIG.1, the function point values reflect a quality of the decision inimplementing these elements in the technical architecture. In someembodiments of the present invention, the decision quality can be one ofthree levels: ideal, less the ideal, and worst. These definitiverankings provide quantitative values to these function points.

Returning to FIG. 1, in some embodiments of the present invention, foreach function point, the program code identifies the architecturaldecisions made for placement, data source and integration type, for thatfunction point (130). Although the program code in embodiments of thepresent invention can be applied to complex decisions in technicalarchitectures, illustrating the evaluation of decisions with a lesscomplex example is provided herein for illustrative purposes. Forexample, in a technical architecture, a given decision for a functionpoint, related to the data source, is if some data required by atransactional system of engagement is to be copied locally or accessedfrom a remote master. Elements that would shape this decision inarchitectural design include, but are not limited to, the desired speedfor completion of a user transaction utilizing this data, the demand forcurrent data (how frequently and quickly the data should be updated),whether the data is to be transformed in a manner specific to theconsuming system, etc. A consideration of these factors can result in anobjective decision.

The program code determines a disorder value for each architecturaldecision (140). As discussed above, in embodiments of the presentinvention, the program code determines that each decision is of aquantifiable quality in a finite set, e.g., ideal, less the ideal, andworst. The amount of disorder in a given architecture would not beincreased if an ideal decision is implemented, thus, an ideal decisioncan be quantified by a disorder value of zero (0). In evaluating eachdecision based on placement, data source and integration type todetermine a disorder value, each element of this determination is notgiven equal weight, in some embodiments of the present invention, basedon the known impact the given element can have on the disorderintroduced by the element. The program code evaluates data sourcingbased on the potential for this element to introduce a highest amount ofdisorder (relative to the other elements). This highest amount is basedon potential impacts to architecture disorder introduced by functionalissues related to data sourcing, including but not limited to,inconsistent or unreliable data, storing and retrieval of data, costs oftransporting data compared to other (sub-optimal) architecturedecisions, etc. Quantitatively, the next highest amount of disorder canbe introduced into an architecture by function placement. The lowestamount of disorder (relative to the other elements), is potentiallyintroduced by integration pattern.

The processing involved in generating disorder values for the variousdecision and function points can be managed in a variety of ways withthe one or more processors executing the program code. In someembodiments of the present invention, the program code determines thedisorder values associated with each decision for the one or morefunction points in parallel, in some embodiments of the presentinvention, the program code cycles through the various function pointsand/or associated decisions to generate disorder values for thedecisions associated with the function points.

In some embodiments of the present invention, the program code assignsnumerical ranges (ordinal values) for disorder values. The range ofvalues can be varied, but consistent over time. For non-limitingexamples provided for illustrative purposes herein, ranges between 0 and50 are utilized. The various values are selected to provide comparativemeasures, thus, depending both on the complexity of a given architecturebeing evaluated by the program code in an embodiment of the presentinvention, and the number of times that the system has been utilized toevaluate various architectures, a range can be utilized that enablesquantitative differentiation between values. In the examples below,utilizing a given range, each element (placement, data source andintegration type) of a decision for a function point, is provided with apotential disorder value, based on the level: ideal, less the ideal,and/or worst.

Data Source Architecture Decision Disorder Values (by level):

Ideal architectural decision disorder value=0

Less Than Ideal architectural decision disorder value=10

Worst architectural decision disorder value=50

Function Placement Architecture Decision Disorder Values (by level):

Ideal architectural decision disorder value=0

Less Than Ideal architectural decision disorder value=5

Worst architectural decision disorder value=20

Integration Pattern Architecture Decision Disorder Values (by level):

Ideal architectural decision disorder value=0

Less Than Ideal architectural decision disorder value=2

Worst architectural decision disorder value=10

Returning to the simplified example with the data source, just forpurposes of the example, an ideal decision is to make a local copy ofthe data, to meet the functional and non-functional requirements of theapplication and the worst decision is to access the data remotely. Thereare therefore three outcomes for a disorder values in the decision: 1)the ideal decision is made; data is copied locally; 2) the worstdecision is made; data is accessed from a remote system during atransaction; and 3) a less than ideal decision is made; e.g., data isaccessed from the remote system, but a temporary cache is created.

Returning to FIG. 1, in some embodiments of the present invention, asaforementioned, the program code assigns disorder values to eachdecision in a function point in the technical architecture (140). Invarious embodiments of the present invention, the program code refers toa data source of compiled past decisions for function points in order toassign values to each function point identified. Thus, in someembodiments of the present invention, the program code accesses one ormore data stores with historical information of architectures previouslyevaluated in order to determine a disorder level (ideal, less the ideal,and/or worst) for a given decision at a function point in thearchitecture. In some embodiments of the present invention, the programcode assigns a disorder value to the actual decision that was taken inthe architectural framework. For example, using the framework above, fordata sources, if the ideal decision was taken, the disorder value=0, ifa less than ideal decision was taken, the disorder value=10 and if theworst decision was taken, the disorder value=50. The program codeindividually evaluates each actual decision related to a function pointand determines if it is an ideal, a less than ideal, or a worstdecision. By bucketing these decisions definitively, a quantitativemeasure of value can be derived by the program code and easily comparedto alternative architectures.

In some embodiments of the present invention, the program codedetermines whether a given actual decision is ideal, less than ideal, orworst by applying a pre-defined litmus test. Some embodiments of thepresent invention include program code (e.g., one or more modules) thatdefines litmus tests for each of the types of architecture decisionsutilized to evaluate a function point (e.g., function placement, datasource, integration type). The program code (with increased intelligencethrough repetition enabling cognitive analysis and machine-learning)applies these litmus tests and scores the decisions in the technicalarchitecture. These tests and scores will then become a part of thescoring for the overall architecture. Tables 1-3 below providenon-limiting examples of litmus tests for function placement, datasource, integration type, that the program code can utilize indetermining a disorder value for the actual decision (implementation) inthe architecture being evaluated by the program code.

Table 1 below is an example of a litmus test for a data source that canbe applied to the earlier discussed data source example. The litmus testincludes requirements of this feature (functional and non-functional) inthe computing system to assist in determining the disorder value of theactual decision in the architecture in the implementation of thefeature. In the first row, the evaluation (by the program code) looks atthe techno-commercial-time ability of the source to scale up to meetload and response requirements. Thus, a negative score means “DO NOTCOPY” while a positive score means “COPY.” As seen below, a 0 score iseffectively a deadlock that can be broken by changing either acapability on the source or a requirement. In the types column, P refersto performance, S refers to security, A refers to availability, and Frefers to function. Where Y=1 and N=0, Y refers to Yes and N refers toNo. In the weight or weightage range, the positive weights favourcopying (data locally).

TABLE 1 Functional or Related Non-Functional Capability Weighted Srl.Requirement of Y = 1, Weight from Source Y = 1, Score negated No. DataClient Type N = 0 (1-5) System N = 0 with column F 1 Very low latency P1 5 Data source is 1 5 required in more suited to getting copying thaninformation for direct access use case [<100 mS] 2 Security of data S 1−2 Storage and 1 −2 in storage and transport transport is a cannot behigh concern encrypted 3 Client needs data A 1 2 Availability 1 2 to behighly of client is available more than of source 4 Tolerance is zero F1 −5 Data Synch is 1 −5 for outdated data not possible in client's usecase(s) 5 Client needs data F 0 5 Data source 1 0 over a longer cannotincrease period of time retention period than is retained in source 6Application F 0 4 Amount of data 1 0 needs to collate to be collated andcompare and compared data from is high. All multiple sources sourcescannot be at different times synchronized or for its functions baselinedfor time. Total 0

Table 2 below is a function placement litmus test executed by theprogram code in some embodiments of the present invention. Thefunctional requirements and the non-functional requirements in thelitmus test are assigned pre-defined weights (W) and are evaluated interms of the fit within the implementation in the architecture. Byapplying this litmus test, like that of Table 1, the program codeevaluates both functional and non-functional requirements. The fitpercentages in this litmus test are an existing system fit percentage,option 1 fit percentage (i.e., a new system fit percentage), option 2fit percentage (i.e., a new system fit percentage), option 3 fitpercentage (i.e., a new system fit percentage), and a bespoke fitpercentage.

TABLE 2 Functional Exstng Op 1 Op 2 Op 3 Bspke Requirements Fit Fit FitFit Fit (Weight 40%) W % Score % Score % Score % Score % Score Req1 4 1040 90 360 25 100 80 320 100 400 Req2 4 10 40 90 360 35 140 10 40 100 400Req3 4 40 160 60 240 45 180 70 280 100 400 Req4 4 100 400 0 0 55 220 30120 100 400 Req5 4 40 160 60 240 65 260 90 360 100 400 Req6 4 90 360 1040 75 300 20 80 100 400 Req7 4 60 240 40 160 15 60 100 400 100 400 Req84 30 120 70 280 5 20 10 40 100 400 Req9 4 20 80 80 320 10 40 80 320 100400 Req10 4 0 0 100 400 20 80 0 0 100 400 Non-Functional Requirements(Weight 20%) Scalability 2 30 60 70 140 95 190 0 0 100 200 Manageability2 50 100 50 100 85 170 90 180 50 100 Extensibility 2 100 200 0 0 75 15020 40 10 20 Security 3 90 270 10 30 65 195 70 210 100 300 Resilience 230 60 70 140 55 110 15 30 100 200 Availability 2 20 40 80 160 45 90 50100 100 200 Vendor 3 60 180 40 120 60 180 10 30 30 90 OrganizationMaturity References 4 20 80 80 320 70 280 5 20 0 0 TCO (Weightage 40%)Capital 30 30 900 70 2100 90 2700 30 900 10 300 Expenditure Operational10 100 1000 0 0 100 1000 80 800 20 200 Expenditure Total 4490 5510 64654270 5610 Scores

Table 3 below is an integration litmus test executed by the program codein some embodiments of the present invention. The functionalrequirements in the litmus test are assigned pre-defined weights forvarious requirements for the architecture of the function point and areevaluated. By applying the litmus test below, the program code evaluatesdecisions related to an enterprise application integration (EAI). Asunderstood by one of skill in the art, EAI refers to the use oftechnologies and services across an enterprise to enable the integrationof software applications and hardware systems. Many proprietary and openprojects provide EAI solution support and EAI is related to middlewaretechnologies. The litmus test below evaluates whether an EAI should beutilized in integrating the data referred to in the example discussed.When applying the litmus test illustrated in Table 3 below, a score ofless than or equal to 6 indicates that an EAI should be utilized for thedisorder value to be desirable (the architecture to be of the desiredquality).

TABLE 3 Technical Capability Required = Weight Weighted No. Requirement1 else 0 (1-5) Score 1 Reuse of pre-existing 0 3 0 EAI service 2Protocol 0 3 0 Transformation 3 Request/response 0 2 0 objecttransformation 4 Information or 0 2 0 function aggregation acrossmultiple sources 5 Information or 0 2 0 function from changing source 6Throttling to 1 2 2 prevent overload of service 7 Covering for 1 1 1failures of call to end point 8 Covering for 1 1 1 failures of call backto client 9 Asycnh service to 1 1 1 synch response conversion 10 Synchservice to 1 1 1 asynch call back conversion 11 Avoid polling and 1 1 1get information when required 12 Need Publish- 1 4 4 Subscribe framework13 Need abstraction 1 3 3 of deployment architecture of source systems(e.g. multiple ISMS servers for circles) 14 Need to connect 1 −4 −4 toDB directly from EAI but EAI layer has no connection pooling capabilityTotal score 10

Referring to FIG. 1, the program code adds the disorder values for thevarious actual decisions for each function point together to generate atotal disorder value for the architecture (150). The equation below,Equation 1, illustrates the calculation of a total disorder value for agiven decision related to a function point in a technical architecture.

For Equation 1:

AD=Architecture Decision

FP=Function Placement; FPLAD#=Function Placement Location ArchitectureDecision Number; FPLAD#−DV=FPLAD# Disorder Value; Possible values:0=Ideal AD, 5=Less than ideal AD, 20=Worst AD

DS=Data Source; DSAD#=Data Source Architecture Decision; DSAD#−DV=DSA#DDisorder Value; Possible values: 0=Ideal AD, 10=Less than ideal AD,50=Worst AD

IP=Integration Pattern; IPAD#=Data Source Architecture Decision Number;IPAD#−DV=IPAD# Disorder Value; Possible values: 0=Ideal AD, 2=Less thanideal AD, 10=Worst AD

Thus, by applying Equation 1, the program code evaluates the definedaspects of a given decision related to a function point in a technicalarchitecture which can impact the disorder of the computing systememploying the technical architecture: function placement, data source,and integration. The program code executing on one or more processors insome embodiments of the present invention applies Equation 1 todetermine a total disorder value for the technical architecture of acomputing system.

Total Disorder Value of the Architecture of the Computing System=

FPLAD1−DV+FPLAD2−DV+FPLAD3−DV+*+DSAD1−DV+DSAD2−DV+

DSAD3−DV+*+IPAD1−DV+IPAD2−DV+IPAD3−DV+*+   Equation 1:

Upon determining a total disorder value, in some embodiments of thepresent invention, the program code displays, to the user, in aninterface, the decisions that most adversely impact the disorder of thearchitecture, impacting quality. The program code can provide the userwith the option of changing a configuration in the architecture toaddress one or more of the issues. In some embodiments of the presentinvention, the program code can provide the user, through the interface,with the opportunity to accept or reject the evaluated architecture,based on the total disorder score. Thus, in some embodiments of thepresent invention, the program code provides the user withrecommendations for improving the quality of the architecture, tasks toaddress specific issues identified in the analysis, and/or enables theuser to implement decisions in the architecture related to decisionsadjudged to adversely impact the architecture (e.g., less than idealdecisions, worst decisions) (160). In some embodiments of the presentinvention, the program code automatically implements configurationchanges to the architecture that would address the issues identified bythe program code. In some embodiments of the present invention, thetechnical architecture being evaluated by the program code is amodel/simulation, that can be changed by the program code, resulting inan updated model/simulation.

Embodiments of the present invention can be applied to complex technicalarchitectures. FIGS. 2-5 are architectures evaluated in accordance withsome embodiments of the present invention. FIGS. 2-3 are an enterprisearchitecture 200 while FIGS. 4-5 are a technical architecture for a datamanagement system 300. Although FIGS. 2-3 portray the same architecture,as do FIGS. 4-5, the latter of each figures depicts a simplified versionof the architectural aspects being analyzed by program code inembodiments of the present invention, in order to provide a qualityscore. Additionally, in illustrating embodiments of the presentinvention with these architectures, reference is made to the workflow100 of FIG. 1. These references are made for illustrative purposes,only, and do not suggest any limitations to future implementations ofvarious aspects of embodiments of the present invention disclosedherein.

Referring to the enterprise architecture 200 of FIG. 2 (inclusive ofFIGS. 2A-2C), in some embodiments of the present invention, the programcode obtains the data comprising the architectural detail of theenterprise architecture 200 (e.g., FIG. 1, 110). The program codeidentifies the function points in the architectural detail of theenterprise architecture 200 (e.g., FIG. 1, 120). The program codeidentifies the function points in the architectural detail of theenterprise architecture 200 as customer management 210 (FP1), customerorders 220 (FP2), customer payments 230 (FP3), order fulfilment 240(FP4), inventory and logistics management 250 (FP5), customer service260 (FP6), management information systems 270 (FP7), enterprise resourceplanning (ERP) 280 (FP8), and business intelligence (BI) 290 (FP9). Insome embodiments of the present invention, the program code references adatabase with descriptive data about solutions in order to automaticallyidentify the function points on the architectural detail of theenterprise architecture 200. In some embodiments of the presentinvention, a user can input this data via an interface, which isobtained by the program code. The program code identifies architecturaldecisions made for placement, data source, and integration type, for theidentified functional points (e.g., FIG. 1, 130) and determines adisorder value for each decision (e.g., FIG. 1, 140). In this example,for ease of understanding, the program code evaluates one decision foreach functional point, in order to simplify the illustration, only. Morethan one decision can be associated with a given function point. Theprogram code applies a litmus test (obtained from a data source) inorder to determine the disorder value for each decision. In someembodiments of the present invention, the program code learns disordervalues for given decisions by evaluating and monitoring pastarchitectures. Thus, the program code can determine the disorder valuesfor the various decisions based on historically applied values. Tocontinue the example of the architectural detail of the enterprisearchitecture 200 of FIGS. 2-3, the program code determines disordervalues for the decisions related to the function points.

Function Points and AD-DVs:

FP1 Customer Life Cycle Management 210:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=2

FP2 Customer Orders 220:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=0

FP3 Customer Payments 230:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=0

FP4 Order Fulfilment 240:

FPAD1−DV=5, DSAD1−DV=10, IPAD1−DV=0

FP5 Inventory & Logistics Management 250:

FPAD1−DV=0, DSAD1−DV=10, IPAD1−DV=2

FP6 Customer Service 260:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=2

FP7 Management Information System 270:

FPAD1−DV=20, DSAD1−DV=50, IPAD1−DV=0

FP8 ERP 280:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=0

FP9 BI 290:

FPAD1−DV=5, DSAD1−DV=0, IPAD1−DV=10

Resulting Total DV=116

Based on the individual disorder values, the program code determines,based on a minimum possible DV=0, a maximum possible DV=80*9=720, thatthe observed DV=˜16% of maximum value. The program code provides theuser with the option of accepting the technical architecture, based onthis evaluation and/or changing aspects of certain design choices (e.g.,FP7), in order to improve the disorder value. The program code can beconfigured with thresholds in order to represent whether a givenpercentage is anticipated to be acceptable for a given function pointand/or overall computing system. For example, in some embodiments of thepresent invention, values greater than or equal to about 20% areconsidered too disordered to be utilized as the architectures forcomputing systems.

Turning to FIGS. 4-5, which depict an application architecture of amaster data management application 400. In some embodiments of thepresent invention, the program code obtains the data comprising thearchitectural detail of the data management application architecture 400(e.g., FIG. 1, 110). The program code identifies the function points inthe architectural detail of the data management application architecture400 (e.g., FIG. 1, 120). The program code identifies the function pointsin the architectural detail of the data management applicationarchitecture 400 as user interface 410 (FP1), data validation 420 (FP2),transient storage 430 (FP3), approval workflow 440 (FP4), orchestrationengine 450 (FP5), jeopardy management 460 (FP6), management informationsystems 270 (FP7), and external application programming interface (API)480 (FP8). The program code can reference a database with descriptivedata about solutions in order to automatically identify the functionpoints on the architectural detail of the data management applicationarchitecture 400. A user can also input this data (e.g., the functionpoints for a given architecture) via an interface, which is obtained bythe program code. The program code identifies architectural decisionsmade for placement, data source, and integration type, for theidentified functional points (e.g., FIG. 1, 130) and determines adisorder value for each decision (e.g., FIG. 1, 140). In this example,as in the last, for ease of understanding, the program code evaluatesone decision for each functional point, in order to simplify theillustration, only. In some embodiments of the present invention, theprogram code applies a litmus test (obtained from a data source) inorder to determine the disorder value for each decision. In someembodiments of the present invention, the program code learns disordervalues for given decisions by evaluating and monitoring pastarchitectures. Thus, the program code can determine the disorder valuesfor the various decisions based on historically applied values. Tocontinue the example of the architectural detail of the data managementapplication architecture 400 of FIGS. 4-5, the program code determinesdisorder values for the decisions related to the function points.

Function Points and AD-DVs:

FP1 User Interface 410:

FPAD1−DV=5, DSAD1−DV=10, IPAD1−DV=2

FP2 Data Validation 420:

FPAD1−DV=5, DSAD1−DV=0, IPAD1−DV=10

FP3 Transient Storage 430:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=0

FP4 Approval Work Flow 440:

FPAD1−DV=5, DSAD1−DV=10, IPAD1−DV=10

FP5 Orchestration Engine 450:

FPAD1−DV=20, DSAD1−DV=10, IPAD1−DV=2

FP6 Jeopardy Management 460:

FPAD1−DV=0, DSAD1−DV=50, IPAD1−DV=2

FP7 Management Information System 470:

FPAD1−DV=0, DSAD1−DV=0, IPAD1−DV=0

FP8 External API 480:

FPAD1−DV=5, DSAD1−DV=0, IPAD1−DV=10

Resulting Total DV=156

Based on the individual disorder values, the program code determines,based on a minimum possible DV=0, a maximum possible DV=80*8=640, thatthe observed DV=˜25% of maximum value. Using the thresholds provided inthe last example (e.g., values greater than or equal to about 20% areconsidered too disordered to be utilized as the architectures forcomputing systems), the program code in some embodiments of the presentinvention recommends that the user cease utilization of the evaluatedarchitecture. The program code can notify the user, e.g., through analert in a user interface, that the user should change the architecturebefore implementation and/or continued use. Based on the resultsprovided, the program code can recommend improving FP5 first, and thenproceeding to other values with less disorder, until the program codere-evaluates the architecture and determines that the disorder value iswithin the pre-defined tolerance. In some embodiments of the presentinvention, as the user changes the architecture detail, the program codeprogressively updates the disorder value. The program code can referencepast analyses to recommend specific decision differences to the user andcan implement decision differences, automatically, in some embodimentsof the present invention.

FIG. 6 depicts various aspects of a technical architecture 600 of acomputing system comprising aspects of some embodiments of the presentinvention. In the illustrated example, the technical architecture 600includes one or more processors 610 to execute program code to completethe aspects of the workflow 100 of FIG. 1. The program code can includeand/or can access a cognitive analysis engine 620. The cognitiveanalysis engine 620 enables the program code to identify function pointsin architecture details of technical architectures being evaluated bythe program code. The cognitive analysis engine 620 is coupled to a datastore 630 which includes results from historical analyses of technicalarchitectures, which the program code utilizes, via cognitive analysis,which can include the cognitive analysis engine 620, as a knowledgebase, to identify the function points and the decisions. The technicalarchitecture 600 also includes a data repository 640, which can beresident in the data store 630, or can be a separate physical one ormore machines, which stores litmus tests for architectural decisions isvarious computing systems. Based on the requirements of a givencomputing system, the program code identifies a litmus test to utilizefor each element in a decision, in order to assign a disorder value tothe decision. In this example, the program code obtains the computingsystem technical architectures to be evaluated as well as datadescribing the requirements of the computing system, via a computingnode 650. The computing node 650 can include a user interface which auser can utilize to enter this data and/or the computing node can be arepository for this type of data, which the program code accesses. Insome embodiments of the present invention, the program code updates thedata store 630 by continuing to monitor the performance of a givencomputing system to update the data store 630 if the disorder of thesystem is not as indicated by the evaluation of the architecture of thatsystem. Thus, moving forward, the intelligence of the program code ingenerating a disorder value will increase in accuracy through machinelearning. The technical architecture 600 also includes a connection toresource management system 660, which manages the technical architectureof one or more computer systems. In some embodiments of the presentinvention, if the program code determines that the architecture of oneor more of the one or more computer system is above an acceptablethreshold for disorder, the program code can automatically or with userapproval (through a user interface such the computing node 650), suggestand/or implement changes to the architecture, via the resourcemanagement system 660.

Embodiments of the present invention include a computer-implementedmethod, a computer program product, and a computer system where programcode executing on one or more processors obtains architecture detail fora given computing system, where the given computing system comprises oneor more function points enabling specific functions within the givencomputing system, and requirements defining aspirational performancebenchmarks for the function points within the given computing system.The program code identifies physical computing components within thegiven computing systems comprising portions of the architecture detailassociated with each of the one or more function points. For eachfunction point and the associated portion of the architecture detail,the program code identifies one or more architectural decisions in theassociated portion. The program code determines a disorder value foreach architectural decision of the one or more architectural decisionson the associated portion. The program code generates a total disordervalue for the architecture detail based on summing the disorder valuesfor each function point of the one or more function points of thearchitectural detail. The program code determines if the total disordervalue exceeds a pre-defined threshold total disorder value for the givencomputing system.

In some embodiments of the present invention, the program code provides,through a user interface communicatively coupled to the one or moreprocessors, an option to facilitate a change to at least one of theassociated portions of the architecture detail, where selecting theoption in the user interface, instructs the one or more processors toimplement the change in the given computing system.

In some embodiments of the present invention, the program code obtains,based on the selecting of the option, an instruction to implement thechange in the given computing system. The program code implements thechange in the given computing system.

In some embodiments of the present invention, the program code obtainingthe architecture detail and requirements defining aspirationalperformance benchmarks for the function points within the givencomputing system comprises the program code receiving the architecturedetail and requirements via user entry through the user interface.

In some embodiments of the present invention, the program code obtainingthe architecture detail comprises the program code monitoring the givencomputing system and based on the monitoring, mapping the givencomputing system to generate the architectural detail.

In some embodiments of the present invention, the program codeidentifying the physical computing components within the given computingsystems comprising portions of the architecture detail associated witheach of the one or more function points comprises the program codequerying a knowledge base in a data store communicatively coupled to theone or more processors.

In some embodiments of the present invention, the program codeidentifying the one or more architectural decisions in the associatedportion comprises the program code identifying the one or morearchitectural decisions in a finite set of architectural decision types.The finite set can comprise: function point placement, function pointdata source and function point integration type.

In some embodiments of the present invention, the program codedetermining if the total disorder value exceeds the pre-definedthreshold total disorder value for the given computing system comprises:the program code determining a maximum disorder value for thearchitectural detail based on summing maximum disorder values for eachfunction point of the one or more function points, the program codecomparing the total disorder value to the maximum disorder value todetermine a percentage of the maximum disorder value the total disordervalue comprises, and the program code comparing the percentage to thepre-defined threshold.

In some embodiments of the present invention, the program codedetermining the disorder value for each architectural decisioncomprises: the program code utilizing the requirements to generate alitmus test to evaluate the portion of the architectural detailassociated with the function point, and the program code determining,based on the litmus test, a quality for each architectural decision,wherein the quality is selected from a finite set and wherein eachquality is associated with a predefined disorder value. The finite setcan comprise decision qualities of ideal, less than ideal, and worst.

In some embodiments of the present invention, the program codeidentifying the one or more architectural decisions in the associatedportion comprises the program code identifying the one or morearchitectural decisions in a finite set of architectural decision types,where the predefined disorder value associated with each quality isbased on the architectural decision type.

In some embodiments of the present invention, based on determining thatthe total disorder value exceeds the pre-defined threshold totaldisorder value for the given computing system, the program code displaysan alert to a user, through a user interface communicatively coupled tothe one or more processors.

Referring now to FIG. 7, a schematic of an example of a computing node,which can be a cloud computing node 10. Cloud computing node 10 is onlyone example of a suitable cloud computing node and is not intended tosuggest any limitation as to the scope of use or functionality ofembodiments of the invention described herein. Regardless, cloudcomputing node 10 is capable of being implemented and/or performing anyof the functionality set forth hereinabove. In an embodiment of thepresent invention, the one or more processors 610 (FIG. 6), componentscomprising the resource management system 660 (FIG. 6), the computingnode 650 (FIG. 6), the data repository 640 (FIG. 6), the data store 630(FIG. 6), and the resources comprising the cognitive analysis engine 620(FIG. 6) can comprise a cloud computing node 10 (FIG. 7) and if not acloud computing node 10, then one or more general computing nodes thatinclude aspects of the cloud computing node 10.

In cloud computing node 10 there is a computer system/server 12, whichis operational with numerous other general purpose or special purposecomputing system environments or configurations. Examples of well-knowncomputing systems, environments, and/or configurations that may besuitable for use with computer system/server 12 include, but are notlimited to, personal computer systems, server computer systems, thinclients, thick clients, handheld or laptop devices, multiprocessorsystems, microprocessor-based systems, set top boxes, programmableconsumer electronics, network PCs, minicomputer systems, mainframecomputer systems, and distributed cloud computing environments thatinclude any of the above systems or devices, and the like.

Computer system/server 12 may be described in the general context ofcomputer system-executable instructions, such as program modules, beingexecuted by a computer system. Generally, program modules may includeroutines, programs, objects, components, logic, data structures, and soon that perform particular tasks or implement particular abstract datatypes. Computer system/server 12 may be practiced in distributed cloudcomputing environments where tasks are performed by remote processingdevices that are linked through a communications network. In adistributed cloud computing environment, program modules may be locatedin both local and remote computer system storage media including memorystorage devices.

As shown in FIG. 7, computer system/server 12 that can be utilized ascloud computing node 10 is shown in the form of a general-purposecomputing device. The components of computer system/server 12 mayinclude, but are not limited to, one or more processors or processingunits 16, a system memory 28, and a bus 18 that couples various systemcomponents including system memory 28 to processor 16.

Bus 18 represents one or more of any of several types of bus structures,including a memory bus or memory controller, a peripheral bus, anaccelerated graphics port, and a processor or local bus using any of avariety of bus architectures. By way of example, and not limitation,such architectures include Industry Standard Architecture (ISA) bus,Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, VideoElectronics Standards Association (VESA) local bus, and PeripheralComponent Interconnect (PCI) bus.

Computer system/server 12 typically includes a variety of computersystem readable media. Such media may be any available media that isaccessible by computer system/server 12, and it includes both volatileand non-volatile media, removable and non-removable media.

System memory 28 can include computer system readable media in the formof volatile memory, such as random access memory (RAM) 30 and/or cachememory 32. Computer system/server 12 may further include otherremovable/non-removable, volatile/non-volatile computer system storagemedia. By way of example only, storage system 34 can be provided forreading from and writing to a non-removable, non-volatile magnetic media(not shown and typically called a “hard drive”). Although not shown, amagnetic disk drive for reading from and writing to a removable,non-volatile magnetic disk (e.g., a “floppy disk”), and an optical diskdrive for reading from or writing to a removable, non-volatile opticaldisk such as a CD-ROM, DVD-ROM or other optical media can be provided.In such instances, each can be connected to bus 18 by one or more datamedia interfaces. As will be further depicted and described below,memory 28 may include at least one program product having a set (e.g.,at least one) of program modules that are configured to carry out thefunctions of embodiments of the invention.

Program/utility 40, having a set (at least one) of program modules 42,may be stored in memory 28 by way of example, and not limitation, aswell as an operating system, one or more application programs, otherprogram modules, and program data. Each of the operating system, one ormore application programs, other program modules, and program data orsome combination thereof, may include an implementation of a networkingenvironment. Program modules 42 generally carry out the functions and/ormethodologies of embodiments of the invention as described herein.

Computer system/server 12 may also communicate with one or more externaldevices 14 such as a keyboard, a pointing device, a display 24, etc.;one or more devices that enable a user to interact with computersystem/server 12; and/or any devices (e.g., network card, modem, etc.)that enable computer system/server 12 to communicate with one or moreother computing devices. Such communication can occur via Input/Output(I/O) interfaces 22. Still yet, computer system/server 12 cancommunicate with one or more networks such as a local area network(LAN), a general wide area network (WAN), and/or a public network (e.g.,the Internet) via network adapter 20. As depicted, network adapter 20communicates with the other components of computer system/server 12 viabus 18. It should be understood that although not shown, other hardwareand/or software components could be used in conjunction with computersystem/server 12. Examples include, but are not limited to: microcode,device drivers, redundant processing units, external disk drive arrays,RAID systems, tape drives, and data archival storage systems, etc.

It is to be understood that although this disclosure includes a detaileddescription on cloud computing, implementation of the teachings recitedherein are not limited to a cloud computing environment. Rather,embodiments of the present invention are capable of being implemented inconjunction with any other type of computing environment now known orlater developed.

Cloud computing is a model of service delivery for enabling convenient,on-demand network access to a shared pool of configurable computingresources (e.g., networks, network bandwidth, servers, processing,memory, storage, applications, virtual machines, and services) that canbe rapidly provisioned and released with minimal management effort orinteraction with a provider of the service. This cloud model may includeat least five characteristics, at least three service models, and atleast four deployment models.

Characteristics are as follows:

On-demand self-service: a cloud consumer can unilaterally provisioncomputing capabilities, such as server time and network storage, asneeded automatically without requiring human interaction with theservice's provider.

Broad network access: capabilities are available over a network andaccessed through standard mechanisms that promote use by heterogeneousthin or thick client platforms (e.g., mobile phones, laptops, and PDAs).Resource pooling: the provider's computing resources are pooled to servemultiple consumers using a multi-tenant model, with different physicaland virtual resources dynamically assigned and reassigned according todemand. There is a sense of location independence in that the consumergenerally has no control or knowledge over the exact location of theprovided resources but may be able to specify location at a higher levelof abstraction (e.g., country, state, or datacenter). Rapid elasticity:capabilities can be rapidly and elastically provisioned, in some casesautomatically, to quickly scale out and rapidly released to quicklyscale in. To the consumer, the capabilities available for provisioningoften appear to be unlimited and can be purchased in any quantity at anytime.

Measured service: cloud systems automatically control and optimizeresource use by leveraging a metering capability at some level ofabstraction appropriate to the type of service (e.g., storage,processing, bandwidth, and active user accounts). Resource usage can bemonitored, controlled, and reported, providing transparency for both theprovider and consumer of the utilized service.

Service Models are as follows:

Software as a Service (SaaS): the capability provided to the consumer isto use the provider's applications running on a cloud infrastructure.The applications are accessible from various client devices through athin client interface such as a web browser (e.g., web-based e-mail).The consumer does not manage or control the underlying cloudinfrastructure including network, servers, operating systems, storage,or even individual application capabilities, with the possible exceptionof limited user specific application configuration settings.

Platform as a Service (PaaS): the capability provided to the consumer isto deploy onto the cloud infrastructure consumer-created or acquiredaFlpplications created using programming languages and tools supportedby the provider. The consumer does not manage or control the underlyingcloud infrastructure including networks, servers, operating systems, orstorage, but has control over the deployed applications and possiblyapplication hosting environment configurations.

Infrastructure as a Service (IaaS): the capability provided to theconsumer is to provision processing, storage, networks, and otherfundamental computing resources where the consumer is able to deploy andrun arbitrary software, which can include operating systems andapplications. The consumer does not manage or control the underlyingcloud infrastructure but has control over operating systems, storage,deployed applications, and possibly limited control of select networkingcomponents (e.g., host firewalls).

Deployment Models are as follows:

Private cloud: the cloud infrastructure is operated solely for anorganization. It may be managed by the organization or a third party andmay exist on-premises or off premises.

Community cloud: the cloud infrastructure is shared by severalorganizations and supports a specific community that has shared concerns(e.g., mission, security requirements, policy, and complianceconsiderations). It may be managed by the organizations or a third partyand may exist on-premises or off-premises.

Public cloud: the cloud infrastructure is made available to the generalpublic or a large industry group and is owned by an organization sellingcloud services.

Hybrid cloud: the cloud infrastructure is a composition of two or moreclouds (private, community, or public) that remain unique entities butare bound together by standardized or proprietary technology thatenables data and application portability (e.g., cloud bursting forload-balancing between clouds).

A cloud computing environment is service oriented with a focus onstatelessness, low coupling, modularity, and semantic interoperability.At the heart of cloud computing is an infrastructure that includes anetwork of interconnected nodes.

Referring now to FIG. 8, illustrative cloud computing environment 50 isdepicted. As shown, cloud computing environment 50 includes one or morecloud computing nodes 10 with which local computing devices used bycloud consumers, such as, for example, personal digital assistant (PDA)or cellular telephone 54A, desktop computer 54B, laptop computer 54C,and/or automobile computer system 54N may communicate. Nodes 10 maycommunicate with one another. They may be grouped (not shown) physicallyor virtually, in one or more networks, such as Private, Community,Public, or Hybrid clouds as described hereinabove, or a combinationthereof. This allows cloud computing environment 50 to offerinfrastructure, platforms and/or software as services for which a cloudconsumer does not need to maintain resources on a local computingdevice. It is understood that the types of computing devices 54A-N shownin FIG. 8 are intended to be illustrative only and that computing nodes10 and cloud computing environment 50 can communicate with any type ofcomputerized device over any type of network and/or network addressableconnection (e.g., using a web browser).

Referring now to FIG. 9, a set of functional abstraction layers providedby cloud computing environment 50 (FIG. 8) is shown. It should beunderstood in advance that the components, layers, and functions shownin FIG. 9 are intended to be illustrative only and embodiments of theinvention are not limited thereto. As depicted, the following layers andcorresponding functions are provided:

Hardware and software layer 60 includes hardware and softwarecomponents. Examples of hardware components include: mainframes 61; RISC(Reduced Instruction Set Computer) architecture based servers 62;servers 63; blade servers 64; storage devices 65; and networks andnetworking components 66. In some embodiments, software componentsinclude network application server software 67 and database software 68.

Virtualization layer 70 provides an abstraction layer from which thefollowing examples of virtual entities may be provided: virtual servers71; virtual storage 72; virtual networks 73, including virtual privatenetworks; virtual applications and operating systems 74; and virtualclients 75.

In one example, management layer 80 may provide the functions describedbelow. Resource provisioning 81 provides dynamic procurement ofcomputing resources and other resources that are utilized to performtasks within the cloud computing environment. Metering and Pricing 82provide cost tracking as resources are utilized within the cloudcomputing environment, and billing or invoicing for consumption of theseresources. In one example, these resources may include applicationsoftware licenses. Security provides identity verification for cloudconsumers and tasks, as well as protection for data and other resources.User portal 83 provides access to the cloud computing environment forconsumers and system administrators. Service level management 84provides cloud computing resource allocation and management such thatrequired service levels are met. Service Level Agreement (SLA) planningand fulfillment 85 provide pre-arrangement for, and procurement of,cloud computing resources for which a future requirement is anticipatedin accordance with an SLA.

Workloads layer 90 provides examples of functionality for which thecloud computing environment may be utilized. Examples of workloads andfunctions which may be provided from this layer include: mapping andnavigation 91; software development and lifecycle management 92; virtualclassroom education delivery 93; data analytics processing 94;transaction processing 95; and determining a quantitative disordervalue, representing the quality of a technical architecture of thecomputing system 96.

The present invention may be a system, a method, and/or a computerprogram product at any possible technical detail level of integration.The computer program product may include a computer readable storagemedium (or media) having computer readable program instructions thereonfor causing a processor to carry out aspects of the present invention.

The computer readable storage medium can be a tangible device that canretain and store instructions for use by an instruction executiondevice. The computer readable storage medium may be, for example, but isnot limited to, an electronic storage device, a magnetic storage device,an optical storage device, an electromagnetic storage device, asemiconductor storage device, or any suitable combination of theforegoing. A non-exhaustive list of more specific examples of thecomputer readable storage medium includes the following: a portablecomputer diskette, a hard disk, a random access memory (RAM), aread-only memory (ROM), an erasable programmable read-only memory (EPROMor Flash memory), a static random access memory (SRAM), a portablecompact disc read-only memory (CD-ROM), a digital versatile disk (DVD),a memory stick, a floppy disk, a mechanically encoded device such aspunch-cards or raised structures in a groove having instructionsrecorded thereon, and any suitable combination of the foregoing. Acomputer readable storage medium, as used herein, is not to be construedas being transitory signals per se, such as radio waves or other freelypropagating electromagnetic waves, electromagnetic waves propagatingthrough a waveguide or other transmission media (e.g., light pulsespassing through a fiber-optic cable), or electrical signals transmittedthrough a wire.

Computer readable program instructions described herein can bedownloaded to respective computing/processing devices from a computerreadable storage medium or to an external computer or external storagedevice via a network, for example, the Internet, a local area network, awide area network and/or a wireless network. The network may comprisecopper transmission cables, optical transmission fibers, wirelesstransmission, routers, firewalls, switches, gateway computers and/oredge servers. A network adapter card or network interface in eachcomputing/processing device receives computer readable programinstructions from the network and forwards the computer readable programinstructions for storage in a computer readable storage medium withinthe respective computing/processing device.

Computer readable program instructions for carrying out operations ofthe present invention may be assembler instructions,instruction-set-architecture (ISA) instructions, machine instructions,machine dependent instructions, microcode, firmware instructions,state-setting data, configuration data for integrated circuitry, oreither source code or object code written in any combination of one ormore programming languages, including an object oriented programminglanguage such as Smalltalk, C++, or the like, and procedural programminglanguages, such as the “C” programming language or similar programminglanguages. The computer readable program instructions may executeentirely on the user's computer, partly on the user's computer, as astand-alone software package, partly on the user's computer and partlyon a remote computer or entirely on the remote computer or server. Inthe latter scenario, the remote computer may be connected to the user'scomputer through any type of network, including a local area network(LAN) or a wide area network (WAN), or the connection may be made to anexternal computer (for example, through the Internet using an InternetService Provider). In some embodiments, electronic circuitry including,for example, programmable logic circuitry, field-programmable gatearrays (FPGA), or programmable logic arrays (PLA) may execute thecomputer readable program instructions by utilizing state information ofthe computer readable program instructions to personalize the electroniccircuitry, in order to perform aspects of the present invention.

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments of theinvention. It will be understood that each block of the flowchartillustrations and/or block diagrams, and combinations of blocks in theflowchart illustrations and/or block diagrams, can be implemented bycomputer readable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof instructions, which comprises one or more executable instructions forimplementing the specified logical function(s). In some alternativeimplementations, the functions noted in the blocks may occur out of theorder noted in the Figures. For example, two blocks shown in successionmay, in fact, be executed substantially concurrently, or the blocks maysometimes be executed in the reverse order, depending upon thefunctionality involved. It will also be noted that each block of theblock diagrams and/or flowchart illustration, and combinations of blocksin the block diagrams and/or flowchart illustration, can be implementedby special purpose hardware-based systems that perform the specifiedfunctions or acts or carry out combinations of special purpose hardwareand computer instructions.

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting. As used herein, thesingular forms “a”, “an” and “the” are intended to include the pluralforms as well, unless the context clearly indicates otherwise. It willbe further understood that the terms “comprises” and/or “comprising”,when used in this specification, specify the presence of statedfeatures, integers, steps, operations, elements, and/or components, butdo not preclude the presence or addition of one or more other features,integers, steps, operations, elements, components and/or groups thereof.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below, if any, areintended to include any structure, material, or act for performing thefunction in combination with other claimed elements as specificallyclaimed. The description of one or more embodiments has been presentedfor purposes of illustration and description, but is not intended to beexhaustive or limited to in the form disclosed. Many modifications andvariations will be apparent to those of ordinary skill in the art. Theembodiment was chosen and described in order to best explain variousaspects and the practical application, and to enable others of ordinaryskill in the art to understand various embodiments with variousmodifications as are suited to the particular use contemplated.

What is claimed is:
 1. A computer-implemented method, comprising:obtaining, by one or more processors, architecture detail for a givencomputing system, wherein the given computing system comprises one ormore function points enabling specific functions within the givencomputing system, and requirements defining aspirational performancebenchmarks for the function points within the given computing system;identifying, by the one or more processors, physical computingcomponents within the given computing systems comprising portions of thearchitecture detail associated with each of the one or more functionpoints; for each function point and the associated portion of thearchitecture detail: identifying, by the one or more processors, one ormore architectural decisions in the associated portion; determining, bythe one or more processors, a disorder value for each architecturaldecision of the one or more architectural decisions on the associatedportion; generating, by the one or more processors, a total disordervalue for the architecture detail based on summing the disorder valuesfor each function point of the one or more function points of thearchitectural detail; and determining, by the one or more processors, ifthe total disorder value exceeds a pre-defined threshold total disordervalue for the given computing system.
 2. The computer-implemented methodof claim 1, further comprising: providing, by the one or moreprocessors, through a user interface communicatively coupled to the oneor more processors, an option to facilitate a change to at least one ofthe associated portions of the architecture detail, wherein selectingthe option in the user interface, instructs the one or more processorsto implement the change in the given computing system.
 3. Thecomputer-implemented method of claim 2, further comprising: obtaining,by the one or more processors, based on the selecting of the option, aninstruction to implement the change in the given computing system; andimplementing, by the one or more processors, the change in the givencomputing system.
 4. The computer-implemented method of claim 1, whereinthe obtaining of the architecture detail and requirements definingaspirational performance benchmarks for the function points within thegiven computing system comprises receiving the architecture detail andrequirements via user entry through the user interface.
 5. Thecomputer-implemented method of claim 1, wherein the obtaining of thearchitecture detail comprises monitoring the given computing system andbased on the monitoring, mapping the given computing system to generatethe architectural detail.
 6. The computer-implemented method of claim 1,wherein identifying the physical computing components within the givencomputing systems comprising portions of the architecture detailassociated with each of the one or more function points comprisesquerying a knowledge base in a data store communicatively coupled to theone or more processors.
 7. The computer-implemented method of claim 1,wherein identifying the one or more architectural decisions in theassociated portion comprises identifying the one or more architecturaldecisions in a finite set of architectural decision types.
 8. Thecomputer implemented method of claim 7, wherein the finite setcomprises: function point placement, function point data source andfunction point integration type.
 9. The computer-implemented method ofclaim 1, wherein determining if the total disorder value exceeds thepre-defined threshold total disorder value for the given computingsystem comprises: determining, by the one or more processors, a maximumdisorder value for the architectural detail based on summing maximumdisorder values for each function point of the one or more functionpoints; comparing, by the one or more processors, the total disordervalue to the maximum disorder value to determine a percentage of themaximum disorder value the total disorder value comprises; andcomparing, by the one or more processors, the percentage to thepre-defined threshold.
 10. The computer-implemented method of claim 1,wherein determining the disorder value for each architectural decisioncomprises: utilizing, by the one or more processors, the requirements togenerate a litmus test to evaluate the portion of the architecturaldetail associated with the function point; and determining, based on thelitmus test, a quality for each architectural decision, wherein thequality is selected from a finite set and wherein each quality isassociated with a predefined disorder value.
 11. Thecomputer-implemented method of claim 10, wherein the finite setcomprises decision qualities of ideal, less than ideal, and worst. 12.The computer-implemented method of claim 11, wherein identifying the oneor more architectural decisions in the associated portion comprisesidentifying the one or more architectural decisions in a finite set ofarchitectural decision types, and wherein the predefined disorder valueassociated with each quality is based on the architectural decisiontype.
 13. The computer-implemented method of claim 1, furthercomprising: based on determining that the total disorder value exceedsthe pre-defined threshold total disorder value for the given computingsystem, displaying, by the one or more processors, an alert to a user,through a user interface communicatively coupled to the one or moreprocessors.
 14. A computer program product comprising: a computerreadable storage medium readable by one or more processors of a sharedcomputing environment and storing instructions for execution by the oneor more processors for performing a method comprising: obtaining, by theone or more processors, architecture detail for a given computingsystem, wherein the given computing system comprises one or morefunction points enabling specific functions within the given computingsystem, and requirements defining aspirational performance benchmarksfor the function points within the given computing system; identifying,by the one or more processors, physical computing components within thegiven computing systems comprising portions of the architecture detailassociated with each of the one or more function points; for eachfunction point and the associated portion of the architecture detail:identifying, by the one or more processors, one or more architecturaldecisions in the associated portion; determining, by the one or moreprocessors, a disorder value for each architectural decision of the oneor more architectural decisions on the associated portion; generating,by the one or more processors, a total disorder value for thearchitecture detail based on summing the disorder values for eachfunction point of the one or more function points of the architecturaldetail; and determining, by the one or more processors, if the totaldisorder value exceeds a pre-defined threshold total disorder value forthe given computing system.
 15. The computer program product of claim14, the method further comprising: providing, by the one or moreprocessors, through a user interface communicatively coupled to the oneor more processors, an option to facilitate a change to at least one ofthe associated portions of the architecture detail, wherein selectingthe option in the user interface, instructs the one or more processorsto implement the change in the given computing system.
 16. The computerprogram product of claim 15, further comprising: obtaining, by the oneor more processors, based on the selecting of the option, an instructionto implement the change in the given computing system; and implementing,by the one or more processors, the change in the given computing system.17. The computer program product of claim 14, wherein the obtaining ofthe architecture detail and requirements defining aspirationalperformance benchmarks for the function points within the givencomputing system comprises receiving the architecture detail andrequirements via user entry through the user interface.
 18. The computerprogram product of claim 14, wherein the obtaining of the architecturedetail comprises monitoring the given computing system and based on themonitoring, mapping the given computing system to generate thearchitectural detail.
 19. The computer program product of claim 14,wherein identifying the physical computing components within the givencomputing systems comprising portions of the architecture detailassociated with each of the one or more function points comprisesquerying a knowledge base in a data store communicatively coupled to theone or more processors.
 20. A computer system comprising: a memory; oneor more processors in communication with the memory; programinstructions executable by the one or more processors in a sharedcomputing environment via the memory to perform a method, the methodcomprising: obtaining, by the one or more processors, architecturedetail for a given computing system, wherein the given computing systemcomprises one or more function points enabling specific functions withinthe given computing system, and requirements defining aspirationalperformance benchmarks for the function points within the givencomputing system; identifying, by the one or more processors, physicalcomputing components within the given computing systems comprisingportions of the architecture detail associated with each of the one ormore function points; for each function point and the associated portionof the architecture detail: identifying, by the one or more processors,one or more architectural decisions in the associated portion;determining, by the one or more processors, a disorder value for eacharchitectural decision of the one or more architectural decisions on theassociated portion; generating, by the one or more processors, a totaldisorder value for the architecture detail based on summing the disordervalues for each function point of the one or more function points of thearchitectural detail; and determining, by the one or more processors, ifthe total disorder value exceeds a pre-defined threshold total disordervalue for the given computing system.